/*
 * Copyright 2004,2004 The Apache Software Foundation.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.bsf.util.cf;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;

import org.apache.bsf.util.IndentWriter;
import org.apache.bsf.util.StringUtils;

import x.java.io.File;

/**
 * A <code>CodeFormatter</code> bean is used to format raw Java code. It
 * indents, word-wraps, and replaces tab characters with an amount of space
 * characters equal to the size of the <code>indentationStep</code> property.
 * To create and use a <code>CodeFormatter</code>, you simply instantiate a
 * new <code>CodeFormatter</code> bean, and invoke
 * <code>formatCode(Reader source, Writer target)</code> with appropriate
 * arguments.
 *
 * @version 1.0
 * @author Matthew J. Duftler
 */
public class CodeFormatter
{
  /**
   * The default maximum line length.
   */
  public static final int     DEFAULT_MAX      = 74;
  /**
   * The default size of the indentation step.
   */
  public static final int     DEFAULT_STEP     = 2;
  /**
   * The default set of delimiters.
   */
  public static final String  DEFAULT_DELIM    = "(+";
  /**
   * The default set of sticky delimiters.
   */
  public static final String  DEFAULT_S_DELIM  = ",";

  // Configurable Parameters
  private             int     maxLineLength    = DEFAULT_MAX;
  private             int     indentationStep  = DEFAULT_STEP;
  private             String  delimiters       = DEFAULT_DELIM;
  private             String  stickyDelimiters = DEFAULT_S_DELIM;

  // Global Variables
  private             int     indent;
  private             int     hangingIndent;
  private             int     origIndent;
  private             boolean inCPP_Comment;

  private void addTok(StringBuffer targetBuf, StringBuffer tokBuf,
					  IndentWriter out)
  {
	int tokLength    = tokBuf.length(),
		targetLength = targetBuf.length();

	if (indent + targetLength + tokLength > maxLineLength)
	{
	  if (targetLength == 0)
	  {
		out.println(indent, tokBuf.toString());
		indent = hangingIndent;
		targetBuf.setLength(0);

		return;
	  }
	  else
	  {
		out.println(indent, targetBuf.toString().trim());
		indent = hangingIndent;
		targetBuf.setLength(0);
	  }
	}

	targetBuf.append(tokBuf.toString());

	return;
  }
  /**
   * Formats the code read from <code>source</code>, and writes the formatted
   * code to <code>target</code>.
   *
   * @param source where to read the unformatted code from.
   * @param target where to write the formatted code to.
   */
  public void formatCode(Reader source, Writer target)
  {
	String         line;
	BufferedReader in  = new BufferedReader(source, File.BUFSIZE);
	IndentWriter   out = new IndentWriter(new BufferedWriter(target), true);

	try
	{
	  origIndent    = 0;
	  inCPP_Comment = false;

	  while ((line = in.readLine()) != null)
	  {
		line = line.trim();

		if (line.length() > 0)
		{
		  indent        = origIndent;
		  hangingIndent = indent + indentationStep;
		  printLine(line, out);
		}
		else
		  out.println();
	  }
	}
	catch (IOException e)
	{
	  e.printStackTrace();
	}
  }
  /**
   * Gets the set of delimiters.
   *
   * @return the set of delimiters.
   * @see #setDelimiters
   */
  public String getDelimiters()
  {
	return delimiters;
  }
  /**
   * Gets the size of the indentation step.
   *
   * @return the size of the indentation step.
   * @see #setIndentationStep
   */
  public int getIndentationStep()
  {
	return indentationStep;
  }
  /**
   * Gets the maximum line length.
   *
   * @return the maximum line length.
   * @see #setMaxLineLength
   */
  public int getMaxLineLength()
  {
	return maxLineLength;
  }
  /**
   * Gets the set of sticky delimiters.
   *
   * @return the set of sticky delimiters.
   * @see #setStickyDelimiters
   */
  public String getStickyDelimiters()
  {
	return stickyDelimiters;
  }
  private void printLine(String line, IndentWriter out)
  {
	char[]       source           = line.toCharArray();
	char         ch;
	char         quoteChar        = ' ';
	boolean      inEscapeSequence = false;
	boolean      inString         = false;
	StringBuffer tokBuf           = new StringBuffer(),
				 targetBuf        = new StringBuffer(hangingIndent + line.length());

	for (int i = 0; i < source.length; i++)
	{
	  ch = source[i];

	  if (inEscapeSequence)
	  {
		tokBuf.append(ch);
		inEscapeSequence = false;
	  }
	  else
	  {
		if (inString)
		{
		  switch (ch)
		  {
			case '\\' :
			  tokBuf.append('\\');
			  inEscapeSequence = true;
			  break;
			case '\'' :
			case '\"' :
			  tokBuf.append(ch);

			  if (ch == quoteChar)
			  {
				addTok(targetBuf, tokBuf, out);
				tokBuf.setLength(0);
				inString = false;
			  }
			  break;
			case 9 :  // pass thru tab characters...
			  tokBuf.append(ch);
			  break;
			default :
			  if (ch > 31)
				tokBuf.append(ch);
			  break;
		  }
		}
		else  // !inString
		{
		  if (inCPP_Comment)
		  {
			tokBuf.append(ch);

			if (ch == '/' && i > 0 && source[i - 1] == '*')
			  inCPP_Comment = false;
		  }
		  else
		  {
			switch (ch)
			{
			  case '/' :
				tokBuf.append(ch);

				if (i > 0 && source[i - 1] == '/')
				{
				  String tokStr = tokBuf.append(source,
												i + 1,
												source.length - (i + 1)).toString();

				  out.println(indent, targetBuf.append(tokStr).toString());

				  return;
				}
				break;
			  case '*' :
				tokBuf.append(ch);

				if (i > 0 && source[i - 1] == '/')
				  inCPP_Comment = true;
				break;
			  case '\'' :
			  case '\"' :
				addTok(targetBuf, tokBuf, out);
				tokBuf.setLength(0);
				tokBuf.append(ch);
				quoteChar = ch;
				inString  = true;
				break;
			  case 9 :  // replace tab characters...
				tokBuf.append(StringUtils.getChars(indentationStep, ' '));
				break;
			  case '{' :
				tokBuf.append(ch);
				origIndent += indentationStep;
				break;
			  case '}' :
				tokBuf.append(ch);
				origIndent -= indentationStep;

				if (i == 0)
				  indent = origIndent;
				break;
			  default :
				if (ch > 31)
				{
				  if (delimiters.indexOf(ch) != -1)
				  {
					addTok(targetBuf, tokBuf, out);
					tokBuf.setLength(0);
					tokBuf.append(ch);
				  }
				  else if (stickyDelimiters.indexOf(ch) != -1)
				  {
					tokBuf.append(ch);
					addTok(targetBuf, tokBuf, out);
					tokBuf.setLength(0);
				  }
				  else
					tokBuf.append(ch);
				}
				break;
			}
		  }
		}
	  }
	}

	if (tokBuf.length() > 0)
	  addTok(targetBuf, tokBuf, out);

	String lastLine = targetBuf.toString().trim();

	if (lastLine.length() > 0)
	  out.println(indent, lastLine);
  }
  /**
   * Sets the set of delimiters; default set is <code>"(+"</code>.
   * <p>
   * Each character represents one delimiter. If a line is ready to be
   * word-wrapped and a delimiter is encountered, the delimiter will
   * appear as the <em>first character on the following line</em>.
   * A quotation mark, <code>"</code> or <code>'</code>, opening a string
   * is always a delimiter, whether you specify it or not.
   *
   * @param newDelimiters the new set of delimiters.
   * @see #getDelimiters
   */
  public void setDelimiters(String newDelimiters)
  {
	delimiters = newDelimiters;
  }
  /**
   * Sets the size of the indentation step; default size is <code>2</code>.
   * <p>
   * This is the number of spaces that lines will be indented (when appropriate).
   * 
   * @param newIndentationStep the new size of the indentation step.
   * @see #getIndentationStep
   */
  public void setIndentationStep(int newIndentationStep)
  {
	indentationStep = (newIndentationStep < 0 ? 0 : newIndentationStep);
  }
  /**
   * Sets the (desired) maximum line length; default length is
   * <code>74</code>.
   * <p>
   * If a token is longer than the requested maximum line length,
   * then the line containing that token will obviously be longer
   * than the desired maximum.
   *
   * @param newMaxLineLength the new maximum line length.
   * @see #getMaxLineLength
   */
  public void setMaxLineLength(int newMaxLineLength)
  {
	maxLineLength = (newMaxLineLength < 0 ? 0 : newMaxLineLength);
  }
  /**
   * Sets the set of sticky delimiters; default set is <code>","</code>.
   * <p>
   * Each character represents one sticky delimiter. If a line is ready
   * to be word-wrapped and a sticky delimiter is encountered, the sticky
   * delimiter will appear as the <em>last character on the current line</em>.
   * A quotation mark, <code>"</code> or <code>'</code>, closing a string
   * is always a sticky delimiter, whether you specify it or not.
   *
   * @param newStickyDelimiters the new set of sticky delimiters.
   * @see #getStickyDelimiters
   */
  public void setStickyDelimiters(String newStickyDelimiters)
  {
	stickyDelimiters = newStickyDelimiters;
  }
}
